﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.Windows.Forms;
using System.ComponentModel;
using System.Drawing;
using CommonTools;
using ProjectA.Modules.Configuracion.Usuarios;

namespace ProjectA.Modules.Costos.Presupuesto
{
    public class cConfPresupuesto
    {
        wsGeneral.WsGeneral wsGeneral;
        public List<cPresupuesto> Presupuestos { get; set; }
        public cPresupuesto Presupuesto { get; set; }
        public List<cItemsFechaCosto> ItemsFechaCosto { get; set; }
        public List<cItemsEstrucPresupuesto> ItemsPorProyecto { get; set; }
        public List<TreeNode> Nodos { get; set; }
        public cProyectos ProyectoSelec { get; set; }
        public int PresupuestoSelected { get; set; }

        public int iCantidadColumnas { get; set; }

        public List<cItemsFechaCosto> GetItemsFechaCosto(int iPresupuestoID, int iItemID)
        {
            string sErrMess = "";
            bool bRespuesta = false;
            DataSet dsData = new DataSet();
            ItemsFechaCosto = new List<cItemsFechaCosto>();
            bRespuesta = wsGeneral.GetItemsFechaCosto(null, iItemID, null, null, null, iPresupuestoID, out dsData, out sErrMess);
            if (bRespuesta)
            {
                for (int a = 0; a < dsData.Tables[0].Rows.Count; a++)
                {
                    cItemsFechaCosto item = new cItemsFechaCosto();
                    item.ID = Convert.ToInt32(dsData.Tables[0].Rows[a][dsData.Tables[0].Columns["ID"]]);
                    item.ItemID = Convert.ToInt32(dsData.Tables[0].Rows[a][dsData.Tables[0].Columns["ItemID"]]);
                    item.PresupuestoID = Convert.ToInt32(dsData.Tables[0].Rows[a][dsData.Tables[0].Columns["PresupuestoID"]]);
                    item.Fecha = Convert.ToDateTime(dsData.Tables[0].Rows[a][dsData.Tables[0].Columns["Fecha"]]);
                    item.Valor = (float)Convert.ToDouble(dsData.Tables[0].Rows[a][dsData.Tables[0].Columns["Valor"]]);
                    ItemsFechaCosto.Add(item);
                }
            }
            return ItemsFechaCosto;
        }


        public void crearTablaValoresPorItems(out DataTable dtData, out DataTable dtPadre)
        {
            dtData = new DataTable();
            dtPadre = new DataTable();
            dtData.Columns.Add("IDEstructura", typeof(int));
            dtData.Columns.Add("IDMestro", typeof(int));
            dtData.Columns.Add("ValorTotal", typeof(float));
            dtPadre.Columns.Add("IDEstructura", typeof(int));
            dtPadre.Columns.Add("IDMestro", typeof(int));
            dtPadre.Columns.Add("ValorTotal", typeof(float));
            for (DateTime a = Presupuesto.FechaInicio; a < Presupuesto.FechaFinal.AddMonths(+1); a = a.AddMonths(+1))
            {
                DateTime dFecha = Convert.ToDateTime("01/" + a.Month + "/" + a.Year);
                dtData.Columns.Add(dFecha.ToShortDateString(), typeof(float));
                dtPadre.Columns.Add(dFecha.ToShortDateString(), typeof(float));
            }
        }

        public DataTable LLenarValoresPorItems(DataTable dtHijo)
        {
            DataTable dt = new DataTable();
            string sError = "";
            int iItem = 0;
            wsGeneral.GetTreelistPresupuestoInfo(Presupuesto.ID, out dt, out sError);
            DataRow dr = dtHijo.NewRow();
            int iposicion = 0;
            for (int x = 0; x < dt.Rows.Count; x++)
            {
                if (x == 0)
                {
                    dr[0] = Convert.ToInt32(dt.Rows[x]["EstructuraID"]);
                    dr[1] = Convert.ToInt32(dt.Rows[x]["MaestroID"]);
                    dr[2] = (float)Convert.ToDouble(dt.Rows[x]["PrecioTotal"]);
                    iItem = Convert.ToInt32(dt.Rows[x]["ItemID"]);
                    iposicion = 3;
                }
                if (iItem == Convert.ToInt32(dt.Rows[x]["ItemID"]))
                {
                    for (int b = iposicion; b < dtHijo.Columns.Count; b++)
                    {
                        DateTime dtime = Convert.ToDateTime(dt.Rows[x]["Fecha"]);
                        if (dtHijo.Columns[b].ColumnName == dtime.ToShortDateString())
                        {
                            dr[b] = (float)Convert.ToDouble(dt.Rows[x]["Valor"]);
                            iposicion = b + 1;
                            break;
                        }
                        else
                            dr[b] = 0;
                    }
                    if (x == dt.Rows.Count - 1)
                    {
                        dtHijo.Rows.Add(dr);
                        dr = dtHijo.NewRow();
                    }
                }
                else if (iItem != Convert.ToInt32(dt.Rows[x]["ItemID"]))
                {
                    dtHijo.Rows.Add(dr);
                    dr = dtHijo.NewRow();
                    dr[0] = Convert.ToInt32(dt.Rows[x]["EstructuraID"]);
                    dr[1] = Convert.ToInt32(dt.Rows[x]["MaestroID"]);
                    dr[2] = (float)Convert.ToDouble(dt.Rows[x]["PrecioTotal"]);
                    iItem = Convert.ToInt32(dt.Rows[x]["ItemID"]);
                    iposicion = 3;
                }
            }
            return dtHijo;
        }

        public DataTable ValoresEstructura(DataTable dthijo, DataTable dtEstructura, DataTable dtPadre, DataTable dgeneral)
        {
            int iPadre = 0;
            DataRow dr = dtPadre.NewRow();
            object[] Valores = new object[dthijo.Columns.Count];
            for (int d = 0; d < Valores.Length; d++)
                Valores[d] = 0;
            for (int a = 0; a < dthijo.Rows.Count; a++)
            {
                if (iPadre != Convert.ToInt32(dthijo.Rows[a]["IDMestro"]))
                {
                    if (a != 0)
                    {
                        for (int d = 0; d < Valores.Length; d++)
                            dr[d] = Valores[d];
                        dtPadre.Rows.Add(dr);
                        dr = dtPadre.NewRow();
                    }
                    iPadre = Convert.ToInt32(dthijo.Rows[a]["IDMestro"]);
                    Valores = new object[dthijo.Columns.Count];
                    for (int d = 0; d < Valores.Length; d++)
                        Valores[d] = 0;
                    Valores[0] = iPadre;
                    for (int b = 0; b < dtEstructura.Rows.Count; b++)
                    {
                        if (Convert.ToInt32(dtEstructura.Rows[b]["ID"]) == iPadre)
                        {
                            Valores[1] = Convert.ToInt32(dtEstructura.Rows[b]["MaestroID"]);
                            break;
                        }
                    }
                }
                if (iPadre == Convert.ToInt32(dthijo.Rows[a]["IDMestro"]))
                {
                    for(int c = 2; c < dthijo.Columns.Count; c++)
                    {
                        if (dthijo.Rows[a][c] != DBNull.Value)
                        {
                            string sValorHijo = Convert.ToDouble(dthijo.Rows[a][c]).ToString("C2");
                            float fValorHijo = (float)Convert.ToDouble((sValorHijo.Replace("$", "")));
                            Valores[c] = float.Parse(Valores[c].ToString()) + fValorHijo;
                        }
                        else
                        {
                            Valores[c] = 0;
                        }
                    }
                    if (a == dthijo.Rows.Count - 1)
                    {
                        for (int d = 0; d < Valores.Length; d++)
                            dr[d] = Valores[d];
                        dtPadre.Rows.Add(dr);
                    }
                }
            }
            for (int f = 0; f < dtPadre.Rows.Count; f++)
                dgeneral.ImportRow(dtPadre.Rows[f]);
            if (iPadre != 0)
            {
                DataTable dtNewPadre = dtPadre.Clone();
                dgeneral = ValoresEstructura(dtPadre, dtEstructura, dtNewPadre, dgeneral);
            }
            return dgeneral;
        }

        public Node FuncionRecursivaCris(Node Parent, DataTable dtEstructura, int iMaestro, DataTable dtValores)
        {
            Node hijo = null;
            float[] Valores = new float[iCantidadColumnas - 2];
            for (int a = 0; a < dtEstructura.Rows.Count; a++)
            {
                if (Convert.ToInt32(dtEstructura.Rows[a]["MaestroID"]) == iMaestro)
                {
                    if (Parent == null)
                    {
                        object[] obj1 = new object[iCantidadColumnas];
                        obj1[0] = dtEstructura.Rows[a]["Descripcion"].ToString();
                        if (dtValores.Rows != null)
                        {
                            if (dtValores.Rows.Count > 0)
                            {
                                for (int d = 0; d < dtValores.Rows.Count; d++)
                                {
                                    if (Convert.ToInt32(dtEstructura.Rows[a][0]) == Convert.ToInt32(dtValores.Rows[d]["IDEstructura"]))
                                    {
                                        for (int e = 2; e < dtValores.Columns.Count; e++)
                                            obj1[e - 1] = Convert.ToDouble(dtValores.Rows[d][e]).ToString("C2");
                                        break;
                                    }
                                    else if (d == dtValores.Rows.Count - 1)
                                    {
                                        for (int e = 1; e < obj1.Length; e++)
                                            obj1[e] = 0;
                                    }
                                }
                            }
                            else
                            {
                                for (int g = 1; g < obj1.Length; g++)
                                    obj1[g] = 0;
                            }
                        }
                        else
                        {
                            for (int g = 1; g < obj1.Length; g++)
                                obj1[g] = 0;
                        }
                        Parent = new Node(obj1);
                        FuncionRecursivaCris(Parent, dtEstructura, Convert.ToInt32(dtEstructura.Rows[a]["ID"]), dtValores);
                    }
                    else
                    {
                        object[] obj = new object[iCantidadColumnas];
                        obj[0] = dtEstructura.Rows[a]["Descripcion"].ToString();
                        if (dtValores.Rows != null)
                        {
                            if (dtValores.Rows.Count > 0)
                            {
                                for (int d = 0; d < dtValores.Rows.Count; d++)
                                {
                                    if (Convert.ToInt32(dtEstructura.Rows[a][0]) == Convert.ToInt32(dtValores.Rows[d]["IDEstructura"]))
                                    {
                                        for (int e = 2; e < dtValores.Columns.Count; e++)
                                        {
                                            if (dtValores.Rows[d][e] != DBNull.Value)
                                                obj[e - 1] = Convert.ToDouble(dtValores.Rows[d][e]).ToString("C2");
                                            else
                                                obj[e - 1] = 0.ToString("C2");
                                        }
                                        break;
                                    }
                                    else if (d == dtValores.Rows.Count - 1)
                                    {
                                        for (int e = 1; e < obj.Length; e++)
                                            obj[e] = 0;
                                    }
                                }
                            }
                            else
                            {
                                for (int g = 1; g < obj.Length; g++)
                                    obj[g] = 0;
                            }
                        }
                        else
                        {
                            for (int g = 1; g < obj.Length; g++)
                                obj[g] = 0;
                        }
                        hijo = new Node(obj);
                        Parent.Nodes.Add(hijo);
                        FuncionRecursivaCris(hijo, dtEstructura, Convert.ToInt32(dtEstructura.Rows[a]["ID"]), dtValores);
                    }
                }

            }
            return Parent;
        }

        public TreeListView CrearTreeList(cPresupuesto PresupuestoSelec, out cPresupuesto PresupuestoNuevoSelec)
        {
            this.Presupuesto = PresupuestoSelec;
            string sErrMes = "";
            DataSet dsData = new DataSet();
            Nodos = new List<TreeNode>();
            TreeListView TreeList = new TreeListView();
            TreeList.Name = "TreeList";
            TreeList.Size = new Size(539, 352);
            TreeList.Location = new Point(16, 20);
            TreeList.MinimumSize = new Size(538, 351);
            TreeList.MaximumSize = new Size(540, 352);
            TreeListColumn Estructura = new TreeListColumn("Estructura", "Estructura", 150);
            TreeList.Columns.Add(Estructura);
            TreeListColumn ValorTotal = new TreeListColumn("ValorTotal", "ValorTotal", 100);
            TreeList.Columns.Add(ValorTotal);
            bool bRespuesta = wsGeneral.GetEstructura(null, ProyectoSelec.ID, null, null, null, null, null, out dsData, out sErrMes);
            if (Presupuesto != null)
            {
                DataTable dgeneral = new DataTable();
                DataTable dtHijo;
                DataTable dtPadre;
                crearTablaValoresPorItems(out dtHijo, out dtPadre);
                dtHijo = LLenarValoresPorItems(dtHijo);

                dgeneral = dtHijo.Clone();
                if (PresupuestoSelec != null)
                {
                    for (int e = 0; e < dtHijo.Rows.Count; e++)
                        dgeneral.ImportRow(dtHijo.Rows[e]);
                    dgeneral = ValoresEstructura(dtHijo, dsData.Tables[0], dtPadre, dgeneral);
                    if (dgeneral.Rows.Count > 0)
                    {
                        for (int i = 0; i < dgeneral.Rows.Count; i++)
                        {
                            if (int.Parse(dgeneral.Rows[i][0].ToString()) != 0 && int.Parse(dgeneral.Rows[i][1].ToString()) == 0)
                            {
                                string sError = "";
                                PresupuestoSelec.ValorTotal = float.Parse(dgeneral.Rows[i][2].ToString());
                                bRespuesta = wsGeneral.ModifyPresupuestos(PresupuestoSelec.ID, PresupuestoSelec.CentroCostoID, PresupuestoSelec.FechaInicio, PresupuestoSelec.FechaFinal, PresupuestoSelec.ValorTotal, PresupuestoSelec.Nombre, out sError);
                                break;
                            }
                        }
                    }
                    for (DateTime a = PresupuestoSelec.FechaInicio; a < PresupuestoSelec.FechaFinal.AddMonths(+1); a = a.AddMonths(+1))
                    {
                        TreeListColumn Columna = new TreeListColumn("Mes " + a.ToShortDateString(), "Mes" + a.ToShortDateString(), 100);
                        TreeList.Columns.Add(Columna);
                    }
                }
                iCantidadColumnas = TreeList.Columns.Count;
                if (bRespuesta)
                {
                    if (dsData.Tables[0] != null)
                    {
                        if (dsData.Tables[0].Rows.Count > 0)
                        {
                            TreeList.Nodes.Add(FuncionRecursivaCris(null, dsData.Tables[0], 0, dgeneral));
                            object[] obj = new object[1];
                            TreeList.Nodes.Add(new Node(obj));
                        }
                    }
                }
                PresupuestoNuevoSelec = PresupuestoSelec;
            }
            else
            {
                PresupuestoNuevoSelec = PresupuestoSelec;
            }
            return TreeList;
        }


        public void ProyectoActual(int ProyectoSeleccionado)
        {
            string sErrMes = "";
            DataSet dsData = new DataSet();
            ProyectoSelec = new cProyectos();
            bool bRespuesta = wsGeneral.GetCentroCostos(ProyectoSeleccionado, null, null, null, null, null, out dsData, out sErrMes);
            if (bRespuesta)
            {
                for (int a = 0; a < dsData.Tables[0].Rows.Count; a++)
                {
                    ProyectoSelec.ID = Convert.ToInt32(dsData.Tables[0].Rows[a][dsData.Tables[0].Columns["ID"]]);
                    ProyectoSelec.Nombre = Convert.ToString(dsData.Tables[0].Rows[a][dsData.Tables[0].Columns["Nombre"]]);
                    ProyectoSelec.Descripcion = Convert.ToString(dsData.Tables[0].Rows[a][dsData.Tables[0].Columns["Descripcion"]]);
                    ProyectoSelec.FechaInicio = Convert.ToDateTime(dsData.Tables[0].Rows[a][dsData.Tables[0].Columns["FechaInicio"]]);
                    ProyectoSelec.FechaFinal = Convert.ToDateTime(dsData.Tables[0].Rows[a][dsData.Tables[0].Columns["FechaFinal"]]);
                    ProyectoSelec.Estado = Convert.ToInt32(dsData.Tables[0].Rows[a][dsData.Tables[0].Columns["Estado"]]);
                }
            }
        }

        public cConfPresupuesto()
        {
            Presupuestos = new List<cPresupuesto>();
            ItemsFechaCosto = new List<cItemsFechaCosto>();
            wsGeneral = new wsGeneral.WsGeneral();
            ProyectoSelec = new cProyectos();
        }

        public void CargarPresupuestos(int iCentroCosto, out List<cPresupuesto> Presupuestos)
        {
            string sErr = "";
            Presupuestos = new List<cPresupuesto>();
            DataSet dsData = new DataSet();
            ProyectoActual(iCentroCosto);
            bool bGetPresupuesto = wsGeneral.GetPresupuestos(null, iCentroCosto, null, null, null, null, out dsData, out sErr);

            for (int a = 0; a < dsData.Tables[0].Rows.Count; a++)
            {
                cPresupuesto Presupuesto = new cPresupuesto();
                int iPresupuesto = Convert.ToInt32(dsData.Tables[0].Rows[a][0]);
                
                Presupuesto.ID = Convert.ToInt32(dsData.Tables[0].Rows[a][0]);
                Presupuesto.CentroCostoID = Convert.ToInt32(dsData.Tables[0].Rows[a][1]);
                Presupuesto.FechaInicio = Convert.ToDateTime(dsData.Tables[0].Rows[a][2]);
                Presupuesto.FechaFinal = Convert.ToDateTime(dsData.Tables[0].Rows[a][3]);
                Presupuesto.ValorTotal = (float)Convert.ToDouble(dsData.Tables[0].Rows[a][4]);
                Presupuesto.Nombre = dsData.Tables[0].Rows[a][5].ToString();
                Presupuesto.Items = ListaItemsPorPresupuesto(iPresupuesto);
                Presupuestos.Add(Presupuesto);
            }
        }

        public List<cItemsPorPresupuesto> ListaItemsPorPresupuesto(int iPresupuesto)
        {
            string sErr = "";
            DataSet dsProyectos = new DataSet();
            List<cItemsPorPresupuesto> ListaItemsPorPresupuesto = new List<cItemsPorPresupuesto>();
            bool bGetPres = wsGeneral.GetItemsPorPresupuesto(null, iPresupuesto, null, null, null, null, null, out dsProyectos, out sErr);
            if (dsProyectos.Tables.Count > 0)
            {
                for (int i = 0; i < dsProyectos.Tables[0].Rows.Count; i++)
                {
                    cItemsPorPresupuesto cIPP = new cItemsPorPresupuesto();
                    cIPP.ID = Convert.ToInt32(dsProyectos.Tables[0].Rows[i][0]);
                    cIPP.PresupuestoID = Convert.ToInt32(dsProyectos.Tables[0].Rows[i][1]);
                    cIPP.EstructuraID = Convert.ToInt32(dsProyectos.Tables[0].Rows[i][2]);
                    cIPP.CantidadTotal = Convert.ToInt32(dsProyectos.Tables[0].Rows[i][3]);
                    cIPP.PrecioUD = Convert.ToInt32(dsProyectos.Tables[0].Rows[i][4]);
                    cIPP.PrecioTotal = Convert.ToInt32(dsProyectos.Tables[0].Rows[i][5]);
                    cIPP.ItemsValorFecha = GetItemsFechaCosto(iPresupuesto, cIPP.ID);
                    cIPP.Numero = dsProyectos.Tables[0].Rows[i]["Numero"].ToString();
                    ListaItemsPorPresupuesto.Add(cIPP);
                }
            }
            return ListaItemsPorPresupuesto;
        } 

        public List<string> LlenarComboBoxPresupuestos(List<cPresupuesto> Presupuestos)
        {
            List<string> cbPresupuestos = new List<string>();
            for (int f = 0; f < Presupuestos.Count; f++)
                cbPresupuestos.Add(Presupuestos[f].Nombre);
            cbPresupuestos.Add("Nuevo Presupuesto");
            return cbPresupuestos;
        }

        public cPresupuesto PresupuestoSeleccionado(string sNombre, List<cPresupuesto> Presupuestos)
        {
            int iSelec = 0;
            for (int i = 0; i < Presupuestos.Count; i++)
            {
                if (Presupuestos[i].Nombre == sNombre)
                {
                    iSelec = i;
                    break;
                }
            }
            return Presupuestos[iSelec];
        }
    
        public int GuardarPresupuesto(cPresupuesto Presupuesto)
        {
            int iregistro = 0;
            try
            {
                int iRegistro = 0;
                string sErrMess = "";
                wsGeneral.AddPresupuestos(Presupuesto.CentroCostoID, Presupuesto.FechaInicio, Presupuesto.FechaFinal, Presupuesto.ValorTotal, Presupuesto.Nombre, out iRegistro, out sErrMess);
                iregistro = iRegistro;
                MessageBox.Show("Presupuesto Creado");
                return iregistro;
            }
            catch (Exception exc)
            {
                MessageBox.Show("Error, " + exc);
                return iregistro;
            }
        }

        public List<cItemsEstrucPresupuesto> LlenarItemsPorPresupuestoInfo(int iCentroID)
        {
            ItemsPorProyecto = new List<cItemsEstrucPresupuesto>();
            DataSet dsData = new DataSet();
            string sErrMess = "";
            bool bRespuesta = false;
            bRespuesta = wsGeneral.GetEstructura(null, iCentroID, null, null, 0, null, null, out dsData, out sErrMess);
            if (bRespuesta)
            {
                for (int a = 0; a < dsData.Tables[0].Rows.Count; a++)
                {
                    cItemsEstrucPresupuesto ItemPorProyecto = new cItemsEstrucPresupuesto();
                    ItemPorProyecto.EstructuraID = Convert.ToInt32(dsData.Tables[0].Rows[a][0]);
                    ItemPorProyecto.CentroID = Convert.ToInt32(dsData.Tables[0].Rows[a][1]);
                    ItemPorProyecto.Numero = (dsData.Tables[0].Rows[a][6]).ToString();
                    ItemPorProyecto.Descripcion = dsData.Tables[0].Rows[a][5].ToString();
                    ItemsPorProyecto.Add(ItemPorProyecto);
                }
            }
            return ItemsPorProyecto;
        }

        public void GuardarItemsPorProyectoDB(cItemsPorPresupuesto ItemsPorPresupuesto, List<cItemsFechaCosto> ItemsMesCosto, cPresupuesto PresupuestoSelec)
        {
            string sError = "";
            int iRegistroID = 0;
            bool bRespuesta = false;
            int iRegistroItemID = 0;
            bool bResp = false;
            DataSet dsData = new DataSet();

            bRespuesta = wsGeneral.AddItemsPorPresupuesto(ItemsPorPresupuesto.PresupuestoID, ItemsPorPresupuesto.EstructuraID, ItemsPorPresupuesto.CantidadTotal, ItemsPorPresupuesto.PrecioUD, ItemsPorPresupuesto.PrecioTotal, ItemsPorPresupuesto.CantidadMeses, out iRegistroID, out sError);
            for (int i = 0; i < ItemsMesCosto.Count; i++)
            {
                bResp = wsGeneral.AddItemsFechaCosto(iRegistroID, ItemsMesCosto[i].Fecha, ItemsMesCosto[i].Cantidad, ItemsMesCosto[i].Valor, ItemsPorPresupuesto.PresupuestoID, out iRegistroItemID, out sError);
            }
            bRespuesta = wsGeneral.ModifyPresupuestos(PresupuestoSelec.ID, PresupuestoSelec.CentroCostoID, PresupuestoSelec.FechaInicio, PresupuestoSelec.FechaFinal, PresupuestoSelec.ValorTotal, PresupuestoSelec.Nombre, out sError);
            if (bResp && bRespuesta)
            {
                MessageBox.Show("Adición Exitosa");
            }
        }
    }
}
